const storageService = require('../../../services/storage')
const appInstance = getApp();
Page({
  data: {
    devices: [], // WiFi 设备列表
    searching: false, // 是否正在搜索
    searchComplete: false, // 是否搜索完成
    noDevices: false, // 是否未找到设备
    searchTimeout: null, // 搜索超时定时器（保留概念，但实际控制由API回调管理）
    containerStyle: '', // 容器样式
    isWifiInitialized: false, // WiFi是否已初始化
    apiError: null, // API错误信息
    isIos: false,

    showGuide: false, // 是否显示指引
    currentStep: 0, // 当前步骤索引
    stepsData: [{
        imageUrl: 'https://img.99666666.xyz/yugang/images/introduce/%E5%BE%AE%E4%BF%A1-%E6%9D%83%E9%99%90.jpg',
        text: '搜索设备时候系统默认跳转到这里'
      },
      {
        imageUrl: 'https://img.99666666.xyz/yugang/images/introduce/%E5%BE%AE%E4%BF%A1-APP.jpg',
        text: '该界面无需操作，返回即可。'
      },
      {
        imageUrl: 'https://img.99666666.xyz/yugang/images/introduce/%E5%BE%AE%E4%BF%A1-%E6%97%A0%E7%BA%BF%E5%B1%80%E5%9F%9F%E7%BD%91.jpg',
        text: '点击无线局域网打开无线列表'
      },
      {
        imageUrl: 'https://img.99666666.xyz/yugang/images/introduce/%E5%BE%AE%E4%BF%A1-Wifi%E5%88%97%E8%A1%A8.jpg',
        text: '确认待添加设备Wifi已出现则返回微信'
      }
    ],
    swiperHeight: 300, // 初始高度
  },

  onLoad: function () {
    appInstance.mtStop(0);
    appInstance.globalData.isAdding = true;
    this.data.isIos = (appInstance.globalData.platform == "ios")

    this._adjustContainerHeight();
    //this.data.isIos = true
    if (this.data.isIos) {
      const isShow = storageService.getIosGuideShow()
      if (isShow == 1) {
        this.setData({
          showGuide: true,
          swiperHeight: appInstance.globalData.windowHeight * 0.4
        })
      } else {
        this.initWifi();
      }
    } else {
      this.initWifi();
    }
  },

  onShow: function () {
    this._adjustContainerHeight();
    // 每次显示页面时，如果WiFi已初始化且不在搜索中，重新开始监听
    if (this.data.isWifiInitialized && this.data.isIos) {
      // 监听获取到WiFi列表数据事件
      wx.onGetWifiList((res) => {
        console.log('接收到WiFi列表更新:', res.wifiList);
        // clearTimeout(this.data.searchTimeout); // 收到回调，清除超时定时器
        // this.setData({ searchTimeout: null });

        this.processWifiList(res.wifiList);

        // 通常onGetWifiList会多次回调，可以在一段时间后手动停止或让用户手动停止
        // 这里我们依赖超时机制或者用户停止
      });
    }
  },

  onHide: function () {
    // 页面隐藏时停止WiFi扫描和监听
    //this.stopWifiScan();
    // 清除可能存在的搜索超时（虽然主要由回调控制，但以防万一）
    if (this.data.searchTimeout) {
      clearTimeout(this.data.searchTimeout);
      this.setData({
        searchTimeout: null
      });
    }
  },

  onUnload: function () {
    // 页面卸载时停止WiFi扫描和监听
    this.stopWifiScan();
    if (this.data.searchTimeout) {
      clearTimeout(this.data.searchTimeout);
      this.setData({
        searchTimeout: null
      });
    }
  },

  // 调整容器高度
  _adjustContainerHeight: function () {
    const windowInfo = wx.getWindowInfo();
    const windowHeight = windowInfo.windowHeight;

    // 使用一个小延迟确保DOM已经渲染
    setTimeout(() => {
      this.createSelectorQuery()
        .select('.container')
        .fields({
          size: true
        }, (res) => {
          // 确保 res 和 res.height 存在
          if (res && res.height !== null && res.height < windowHeight) {
            const containerStyle = `min-height:${windowHeight}px; background-color:var(--bg-color, #121212);`;
            // 使用 min-height 避免内容过少时页面塌陷，同时允许内容超出
            if (this.data.containerStyle !== containerStyle) {
              this.setData({
                containerStyle: containerStyle
              });
            }
          } else if (res && res.height >= windowHeight) {
            // 如果内容足够多，移除特定高度设置，让其自然滚动
            if (this.data.containerStyle !== '') {
              this.setData({
                containerStyle: ''
              });
            }
          }
        })
        .exec();
    }, 100);
  },

  // 初始化WiFi模块
  initWifi: function () {
    wx.startWifi({
      success: (res) => {
        console.log('WiFi模块初始化成功:', res);
        this.setData({
          isWifiInitialized: true,
          apiError: null
        });
        this.startWifiScan(); // 初始化成功后开始扫描
      },
      fail: (err) => {
        appInstance.logErr("WiFi模块初始化失败:", err)
        console.error('WiFi模块初始化失败:', err);
        this.setData({
          isWifiInitialized: false,
          searching: false,
          apiError: 'WiFi初始化失败，请检查权限或开启WiFi'
        });
        wx.showToast({
          title: 'WiFi初始化失败',
          icon: 'none'
        });
      }
    });
  },

  // 开始搜索设备 (按钮触发)
  startSearch: function () {
    // 清除之前的状态
    this.setData({
      searching: true,
      searchComplete: false,
      noDevices: false,
      devices: [],
      apiError: null, // 清除旧错误
    });

    if (!this.data.isWifiInitialized) {
      console.log('WiFi未初始化，尝试重新初始化...');
      this.initWifi(); // 如果WiFi未初始化，尝试再次初始化
    } else {
      console.log('WiFi已初始化，开始扫描...');
      this.startWifiScan(); // 如果已初始化，直接开始扫描
    }
    // 设置一个超时，以防onGetWifiList长时间不回调
    const timeout = 15000; // 15秒超时
    const searchTimeoutId = setTimeout(() => {
      if (this.data.searching) { // 如果仍在搜索状态
        console.log('WiFi扫描超时');
        wx.stopWifi(); // 停止WiFi模块，可能需要重新初始化
        this.setData({
          searching: false,
          searchComplete: true,
          noDevices: this.data.devices.length === 0, // 基于当前已发现设备判断
          apiError: '搜索超时，请重试',
          isWifiInitialized: false, // 标记WiFi需要重新初始化
          searchTimeout: null
        });
        wx.showToast({
          title: '搜索超时',
          icon: 'none'
        });
        this._adjustContainerHeight(); // 调整高度
      }
    }, timeout);
    this.setData({
      searchTimeout: searchTimeoutId
    });

  },

  // 开始WiFi扫描和监听
  startWifiScan: function () {
    if (!this.data.isWifiInitialized /*|| this.data.searching*/ ) return; // 防止重复调用或未初始化时调用
    console.log('开始监听WiFi列表更新...');
    this.setData({
      searching: true,
      searchComplete: false,
      noDevices: false,
      devices: [],
      apiError: null
    });

    if (!this.data.isIos) {
      // 监听获取到WiFi列表数据事件
      wx.onGetWifiList((res) => {
        console.log('接收到WiFi列表更新:', res.wifiList);
        // clearTimeout(this.data.searchTimeout); // 收到回调，清除超时定时器
        // this.setData({ searchTimeout: null });

        this.processWifiList(res.wifiList);

        // 通常onGetWifiList会多次回调，可以在一段时间后手动停止或让用户手动停止
        // 这里我们依赖超时机制或者用户停止
      });
    }

    // 开始获取WiFi列表
    wx.getWifiList({
      success: (res) => {
        console.log('首次调用 getWifiList 成功');
        // 首次调用成功，后续更新依赖 onGetWifiList
        // 注意：某些情况下首次getWifiList可能为空，需要依赖onGetWifiList更新
      },
      fail: (err) => {
        appInstance.logErr("调用 getWifiList 失败:", err)
        console.error('调用 getWifiList 失败:', err);
        clearTimeout(this.data.searchTimeout); // 出错，清除超时
        this.setData({
          searching: false,
          searchComplete: true,
          noDevices: true,
          apiError: '获取WiFi列表失败',
          searchTimeout: null
        });
        wx.showToast({
          title: '获取WiFi列表失败',
          icon: 'none'
        });
        this.stopWifiScan(); // 获取失败时尝试停止扫描
      }
    });
  },

  // 停止WiFi扫描和监听
  stopWifiScan: function () {
    if (this.data.isWifiInitialized) {
      console.log('停止WiFi扫描和监听...');
      wx.stopWifi({ // 停止WiFi模块会停止扫描和监听
        success: () => console.log('成功停止WiFi模块'),
        fail: (err) => console.error('停止WiFi模块失败:', err)
      });
      // 不再需要单独调用 wx.offGetWifiList() 因为 stopWifi 会处理
      this.setData({
        searching: false,
        isWifiInitialized: false
      }); // 标记需要重新初始化
    }
    // 清除超时定时器
    if (this.data.searchTimeout) {
      clearTimeout(this.data.searchTimeout);
      this.setData({
        searchTimeout: null
      });
    }
  },

  // 处理获取到的WiFi列表
  processWifiList: function (wifiList) {
    if (!wifiList || wifiList.length === 0) {
      console.log('收到的WiFi列表为空');
      // 如果是首次且列表为空，可以暂时不更新UI或标记为未找到
      // 如果是后续更新且为空，则忽略
      // 这里简单处理：如果当前devices为空，且收到空列表，标记noDevices
      if (this.data.devices.length === 0) {
        // this.setData({ noDevices: true }); // 暂时不直接标记，等超时或手动停止
      }
      //this.stopWifiScan();
      return;
    }

    // 设备计数器
    let deviceCounter = 1;

    const filteredDevices = wifiList.filter(wifi => {
      return wifi.SSID.startsWith('HzLamp_hs_') || wifi.SSID.startsWith('HzLamp_ds_') || wifi.SSID.startsWith('HzLamp_dd_') || wifi.SSID.startsWith('HzLamp_hd_') || wifi.SSID == "light_wifi";
    }).map(wifi => {
      // 识别设备类型
      let isFreshwater = false;
      let isDIY = false;
      let deviceType = '';

      if (wifi.SSID.startsWith('HzLamp_ds_')) {
        isFreshwater = true;
        deviceType = 'freshwater_lamp';
      } else if (wifi.SSID.startsWith('HzLamp_hs_')) {
        isFreshwater = false;
        deviceType = 'seawater_lamp';
      } else if (wifi.SSID.startsWith('HzLamp_dd_')) {
        isFreshwater = true; // 淡水类型
        isDIY = true; // DIY标识
        deviceType = 'freshwater_diy_lamp';
      } else if (wifi.SSID.startsWith('HzLamp_hd_')) {
        isFreshwater = false; // 海水类型
        isDIY = true; // DIY标识
        deviceType = 'seawater_diy_lamp';
      } else if (wifi.SSID == "light_wifi") {
        isFreshwater = false; // 传统类型
        isDIY = true; // DIY标识
        deviceType = 'orig_diy_lamp';
      }

      const signalStrength = this.convertSignalToLevel(wifi.signalStrength);

      return {
        //id: randomId,
        //bssid: wifi.BSSID,
        name: `新设备${deviceCounter++}`,
        ssid: wifi.SSID,
        signal: signalStrength,
        isFreshwater: isFreshwater, // 保留isFreshwater以便向后兼容或简化判断
        isDIY: isDIY, // 新增 isDIY 标识
        deviceType: deviceType // 设备类型标识
      };
    });

    console.log('处理后的设备列表:', filteredDevices);
    const map = new Map();
    filteredDevices.forEach(item => {
      // 如果Map中还没有当前item.xx这个键，则设置该键，值为当前item
      if (!map.has(item.ssid)) {
        map.set(item.ssid, item);
      }
    });
    const newfilteredDevices = Array.from(map.values()); // 将Map的值转换为数组

    this.setData({
      devices: newfilteredDevices, //updatedDevices,
      searching: false, // 保持搜索状态，因为onGetWifiList可能多次回调
      searchComplete: true, // 搜索未完成
      noDevices: newfilteredDevices.length === 0, // 只有当处理后列表为空才标记
    }, () => {
      this._adjustContainerHeight();
    });
    this.stopWifiScan();
  },

  // 将信号强度 (dBm) 转换为 1-4 等级
  convertSignalToLevel: function (signalStrength) {
    // dBm 值越大信号越好，通常为负数
    if (signalStrength >= -55) {
      return 4; // 强
    } else if (signalStrength >= -70) {
      return 3; // 中
    } else if (signalStrength >= -85) {
      return 2; // 弱
    } else {
      return 1; // 非常弱
    }
  },

  // 选择设备，跳转到配网页面
  selectDevice: function (e) {
    const ssid = e.currentTarget.dataset.id;
    const device = this.data.devices.find(item => item.ssid === ssid);

    if (!device) {
      wx.showToast({
        title: '设备信息获取失败',
        icon: 'none'
      });
      return;
    }

    console.log('选择的设备:', device);

    // 恢复跳转到根目录的配网页面，传递所有必要信息，包括 deviceType
    const url = `/packageAddDevice/pages/device_config/device_config?ssid=${encodeURIComponent(device.ssid)}&isFreshwater=${device.isFreshwater}&displayName=${encodeURIComponent(device.name)}&deviceType=${encodeURIComponent(device.deviceType)}&signal=${device.signal}`; // 传递 deviceType

    // 停止当前的WiFi扫描，避免影响后续连接
    this.stopWifiScan();

    wx.navigateTo({
      url: url,
      success: () => {
        console.log('成功跳转到配网页面');
      },
      fail: (err) => {
        appInstance.logErr("跳转失败:", err)
        console.error('跳转失败:', err);
        wx.showToast({
          title: '跳转失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 事件处理函数
  onGuideMaskTap: function (e) {},

  onGuideStepChange: function (e) {},

  onGuideClose: function () {
    this.setData({
      showGuide: false
    });
    this.initWifi();
  },

  onGuideDontRemind: function () {
    this.setData({
      showGuide: false
    });
    storageService.setIosGuideNotShow()
    this.initWifi();
  },


})